bun test: scan each directory once, however many symlinks lead to it - #44487

Question for a maintainer. The walk records a directory that only a link leads to under its real path. A substring filter or a file ignore pattern that names only the link path stops matching. Is that acceptable? If not, a filter pass that runs after the walk, only on trees with links, can keep both names (about 55 more lines). The other way, one listing per link path, brings back the growth this PR removes.

Stacking. The base branch is #42921 (robobun/730a1a7f/test-scanner-cached-dirs). An earlier version of this PR had its own replay of a cached listing for a followed directory (a link to a parent of the cwd needs it). #42921 does that in the resolver for every directory, so the copy is gone. If #42921 does not merge, this PR needs that replay back.

The rule, in the directory arm of Scanner::next, after the existing prunes.

1. An entry that is not a link, in a directory the walk did not enter through a link: unchanged.
2. A link with real path P. If P is the place of the link itself (a Windows reparse point that is not an alias), it is a plain child. If P is the scan root, or is below the root with no pruned name on the way, the walk skips it: the walk lists P by itself. If the walk already followed a link to P, it skips it. Otherwise it records P and lists P once, by absolute real path.
3. A real child of a directory that the walk entered through a link: the same tests, with P = parent + name.
4. A path that does not fit a path buffer: not owned, so the base behaviour.

Cost, measured. Release builds of the base (#42921 at ca43827) and of this PR (1ec4bee), built in the same directory with the same toolchain, linux x64. Counts come from gdb: catch syscall with ignore counts, breakpoints on the mimalloc entry points, and stepi through one call.

• Link-free walk: openat/getdents64/close/stat/readlink per directory 1/2/1/0/0 (base 1/2/1/0/0). The whole-process counts are equal on trees of 51 and 251 directories.
• Link-free walk: 3.33 allocator calls per directory (base 3.33). The whole-process totals are equal: 4,246 and 4,911.
• Scanner::next, directory entry: 102 instructions (base 95). The 7 are the test of the link bit and the test of "this directory was entered through a link".
• Entry 144 B, EntryCache 24 B, ScanEntry 56 B (all unchanged). Scanner +72 B, one per process.
• Listings = distinct directories on 8 of 8 link trees (a breakpoint on the scanner's directory read against an independent count of reachable real directories). /usr/lib/llvm-23, an installed Debian package: 443 listings for 443 directories. The base never ends there, because build/Release -> .. and build/Debug+Asserts -> .. both lead to the parent.
• A link to a directory the walk covers: 4 fewer syscalls than the base (no open, 2 getdents64, close). The stat of the link is the same 5 syscalls. The real path of the root costs 3 syscalls, once per scan, and only when the scan meets a directory link.
• The recorded set is identical across 12 of 12 combinations of creation order (link first, link last), filesystem (ext4, tmpfs) and tree (alias, two aliases, two links to one outside directory). Each difference from the base is an alias path of a file the base also runs.
• Release binary: +7,424 bytes of text (size: 105,075,871 to 105,083,295). Data and bss are equal. The file grows by 8,192 bytes.

Listings on the base and on this PR.

Results: Bun 1.4.3 (367d939) against this branch. Each cell is tests / files from the Ran line.

Filters and ignore patterns, tree proj/shared -> ../outside, cwd proj.

• bun test shared/: 1.4.3 runs the test. This branch matches nothing and exits 1.
• bun test outside/: 1.4.3 matches nothing. This branch runs the test.
• bun test ./shared: both run the test.
• --path-ignore-patterns 'shared/**' and 'shared': both prune the link.
• --path-ignore-patterns 'shared/*.test.js': 1.4.3 ignores the file. This branch runs it.
• --path-ignore-patterns '../outside/**': 1.4.3 runs the file. This branch ignores it.

The 8 new tests that pass on 1.4.3 too. They pin what must not change: a test that only a link leads to still runs, a filter on the real path still matches, and a link that is the scan root still works. A walk that opens each directory with O_NOFOLLOW cannot reach the directories of the first group.

Why 1.4.0 ended. Before #40016 (in 1.4.1, not in 1.4.0) the walk held one fd for each directory, so it ended when no file descriptor was left.

What I ran. On a debug build of this head: the 25 directory links tests and the 15 cases of #42921 pass, with path-ignore-patterns.test.ts (10 pass), test-shard.test.ts (29 pass), pass-with-no-tests.test.ts (5 pass), test-changed.test.ts (20 pass) and test/regression/issue/26851.test.ts (2 pass). The rest of bun-test.test.ts passes, except that two cases of "nested too deeply to print" from #44353 take 5.5 s on my debug build and hit the 5 s limit, with and without this diff. CI ran the file on every lane, Windows included, where the rows use junctions.

Known limits.

• A directory between the root and a link target that can be searched but not read (chmod 111): the walk skips the link as covered, and cannot list that directory by itself.
• Remove get_fd_path: derive paths from cwd and what was opened, not from fds #38365 removes get_fd_path and the real path from RealFS::kind. After it, the scanner's own lookup names every link target (open, fd path, close: 3 syscalls per directory link, 0 on a tree with no links), and real_path_of moves to bun_sys::realpath.
• Other walks with the same defect, not changed here: bust_dir_cache_recursive (src/runtime/api/filesystem_router.rs) and FrameworkRouter::scan_inner (src/runtime/bake/FrameworkRouter.rs).

The reproductions come from #41465. That PR keeps only its other half, the report of a directory that cannot be read.